package com.zhangyj.db;

import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Calendar;
import java.util.Set;

public interface NamedPreparedStatement extends PreparedStatement {
	/**
	 * Get the parameter names set
	 * 
	 * @return the set of parameter names
	 */
	Set<String> getParameterNames();

	/**
	 * Sets the designated parameter to SQL <code>NULL</code>.
	 * 
	 * <P>
	 * <B>Note:</B> You must specify the parameter's SQL type.
	 * 
	 * @param parameterIndex
	 *            the first parameter is 1, the second is 2, ...
	 * @param sqlType
	 *            the SQL type code defined in <code>java.sql.Types</code>
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setNull(String parameterName, int sqlType) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>boolean</code>
	 * value. The driver converts this to an SQL <code>BIT</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setBoolean(String parameterName, boolean x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>byte</code> value.
	 * The driver converts this to an SQL <code>TINYINT</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setByte(String parameterName, byte x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>short</code> value.
	 * The driver converts this to an SQL <code>SMALLINT</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setShort(String parameterName, short x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>int</code> value.
	 * The driver converts this to an SQL <code>INTEGER</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setInt(String parameterName, int x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>long</code> value.
	 * The driver converts this to an SQL <code>BIGINT</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setLong(String parameterName, long x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>float</code> value.
	 * The driver converts this to an SQL <code>FLOAT</code> value when it sends
	 * it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setFloat(String parameterName, float x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>double</code>
	 * value. The driver converts this to an SQL <code>DOUBLE</code> value when
	 * it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setDouble(String parameterName, double x) throws SQLException;

	/**
	 * Sets the designated parameter to the given
	 * <code>java.math.BigDecimal</code> value. The driver converts this to an
	 * SQL <code>NUMERIC</code> value when it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setBigDecimal(String parameterName, BigDecimal x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>String</code>
	 * value. The driver converts this to an SQL <code>VARCHAR</code> or
	 * <code>LONGVARCHAR</code> value (depending on the argument's size relative
	 * to the driver's limits on <code>VARCHAR</code> values) when it sends it
	 * to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setString(String parameterName, String x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java <code>String</code>
	 * value. The driver converts this to an SQL <code>CHAR</code>value
	 * (depending on the argument's size relative to the driver's limits on
	 * <code>CHAR</code> values) when it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setChar(String parameterName, String x) throws SQLException;

	void setChar(int parameterIndex, String x) throws SQLException;

	/**
	 * Sets the designated parameter to the given Java array of bytes. The
	 * driver converts this to an SQL <code>VARBINARY</code> or
	 * <code>LONGVARBINARY</code> (depending on the argument's size relative to
	 * the driver's limits on <code>VARBINARY</code> values) when it sends it to
	 * the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setBytes(String parameterName, byte x[]) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>java.sql.Date</code>
	 * value. The driver converts this to an SQL <code>DATE</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setDate(String parameterName, java.sql.Date x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>java.sql.Time</code>
	 * value. The driver converts this to an SQL <code>TIME</code> value when it
	 * sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setTime(String parameterName, java.sql.Time x) throws SQLException;

	/**
	 * Sets the designated parameter to the given
	 * <code>java.sql.Timestamp</code> value. The driver converts this to an SQL
	 * <code>TIMESTAMP</code> value when it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setTimestamp(String parameterName, java.sql.Timestamp x) throws SQLException;

	/**
	 * Sets the designated parameter to the given input stream, which will have
	 * the specified number of bytes. When a very large ASCII value is input to
	 * a <code>LONGVARCHAR</code> parameter, it may be more practical to send it
	 * via a <code>java.io.InputStream</code>. Data will be read from the stream
	 * as needed until end-of-file is reached. The JDBC driver will do any
	 * necessary conversion from ASCII to the database char format.
	 * 
	 * <P>
	 * <B>Note:</B> This stream object can either be a standard Java stream
	 * object or your own subclass that implements the standard interface.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the Java input stream that contains the ASCII parameter value
	 * @param length
	 *            the number of bytes in the stream
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setAsciiStream(String parameterName, java.io.InputStream x, int length) throws SQLException;

	/**
	 * Sets the designated parameter to the given input stream, which will have
	 * the specified number of bytes. When a very large binary value is input to
	 * a <code>LONGVARBINARY</code> parameter, it may be more practical to send
	 * it via a <code>java.io.InputStream</code> object. The data will be read
	 * from the stream as needed until end-of-file is reached.
	 * 
	 * <P>
	 * <B>Note:</B> This stream object can either be a standard Java stream
	 * object or your own subclass that implements the standard interface.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the java input stream which contains the binary parameter
	 *            value
	 * @param length
	 *            the number of bytes in the stream
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setBinaryStream(String parameterName, java.io.InputStream x, int length) throws SQLException;

	// ----------------------------------------------------------------------
	// Advanced features:

	/**
	 * <p>
	 * Sets the value of the designated parameter with the given object. The
	 * second argument must be an object type; for integral values, the
	 * <code>java.lang</code> equivalent objects should be used.
	 * 
	 * <p>
	 * The given Java object will be converted to the given targetSqlType before
	 * being sent to the database.
	 * 
	 * If the object has a custom mapping (is of a class implementing the
	 * interface <code>SQLData</code>), the JDBC driver should call the method
	 * <code>SQLData.writeSQL</code> to write it to the SQL data stream. If, on
	 * the other hand, the object is of a class implementing <code>Ref</code>,
	 * <code>Blob</code>, <code>Clob</code>, <code>Struct</code>, or
	 * <code>Array</code>, the driver should pass it to the database as a value
	 * of the corresponding SQL type.
	 * 
	 * <p>
	 * Note that this method may be used to pass database-specific abstract data
	 * types.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the object containing the input parameter value
	 * @param targetSqlType
	 *            the SQL type (as defined in java.sql.Types) to be sent to the
	 *            database. The scale argument may further qualify this type.
	 * @param scale
	 *            for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
	 *            this is the number of digits after the decimal point. For all
	 *            other types, this value will be ignored.
	 * @exception SQLException
	 *                if a database access error occurs
	 * @see Types
	 */
	void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException;

	/**
	 * Sets the value of the designated parameter with the given object. This
	 * method is like the method <code>setObject</code> above, except that it
	 * assumes a scale of zero.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the object containing the input parameter value
	 * @param targetSqlType
	 *            the SQL type (as defined in java.sql.Types) to be sent to the
	 *            database
	 * @exception SQLException
	 *                if a database access error occurs
	 */
	void setObject(String parameterName, Object x, int targetSqlType) throws SQLException;

	/**
	 * <p>
	 * Sets the value of the designated parameter using the given object. The
	 * second parameter must be of type <code>Object</code>; therefore, the
	 * <code>java.lang</code> equivalent objects should be used for built-in
	 * types.
	 * 
	 * <p>
	 * The JDBC specification specifies a standard mapping from Java
	 * <code>Object</code> types to SQL types. The given argument will be
	 * converted to the corresponding SQL type before being sent to the
	 * database.
	 * 
	 * <p>
	 * Note that this method may be used to pass datatabase- specific abstract
	 * data types, by using a driver-specific Java type.
	 * 
	 * If the object is of a class implementing the interface
	 * <code>SQLData</code>, the JDBC driver should call the method
	 * <code>SQLData.writeSQL</code> to write it to the SQL data stream. If, on
	 * the other hand, the object is of a class implementing <code>Ref</code>,
	 * <code>Blob</code>, <code>Clob</code>, <code>Struct</code>, or
	 * <code>Array</code>, the driver should pass it to the database as a value
	 * of the corresponding SQL type.
	 * <P>
	 * This method throws an exception if there is an ambiguity, for example, if
	 * the object is of a class implementing more than one of the interfaces
	 * named above.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the object containing the input parameter value
	 * @exception SQLException
	 *                if a database access error occurs or the type of the given
	 *                object is ambiguous
	 */
	void setObject(String parameterName, Object x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>Reader</code> object,
	 * which is the given number of characters long. When a very large UNICODE
	 * value is input to a <code>LONGVARCHAR</code> parameter, it may be more
	 * practical to send it via a <code>java.io.Reader</code> object. The data
	 * will be read from the stream as needed until end-of-file is reached. The
	 * JDBC driver will do any necessary conversion from UNICODE to the database
	 * char format.
	 * 
	 * <P>
	 * <B>Note:</B> This stream object can either be a standard Java stream
	 * object or your own subclass that implements the standard interface.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param reader
	 *            the <code>java.io.Reader</code> object that contains the
	 *            Unicode data
	 * @param length
	 *            the number of characters in the stream
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setCharacterStream(String parameterName, java.io.Reader reader, int length) throws SQLException;

	/**
	 * Sets the designated parameter to the given
	 * <code>REF(&lt;structured-type&gt;)</code> value. The driver converts this
	 * to an SQL <code>REF</code> value when it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            an SQL <code>REF</code> value
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setRef(String parameterName, Ref x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>Blob</code> object. The
	 * driver converts this to an SQL <code>BLOB</code> value when it sends it
	 * to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            a <code>Blob</code> object that maps an SQL <code>BLOB</code>
	 *            value
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setBlob(String parameterName, Blob x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>Clob</code> object. The
	 * driver converts this to an SQL <code>CLOB</code> value when it sends it
	 * to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            a <code>Clob</code> object that maps an SQL <code>CLOB</code>
	 *            value
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setClob(String parameterName, Clob x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>Array</code> object. The
	 * driver converts this to an SQL <code>ARRAY</code> value when it sends it
	 * to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            an <code>Array</code> object that maps an SQL
	 *            <code>ARRAY</code> value
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setArray(String parameterName, Array x) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>java.sql.Date</code>
	 * value, using the given <code>Calendar</code> object. The driver uses the
	 * <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
	 * which the driver then sends to the database. With a <code>Calendar</code>
	 * object, the driver can calculate the date taking into account a custom
	 * timezone. If no <code>Calendar</code> object is specified, the driver
	 * uses the default timezone, which is that of the virtual machine running
	 * the application.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @param cal
	 *            the <code>Calendar</code> object the driver will use to
	 *            construct the date
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setDate(String parameterName, java.sql.Date x, Calendar cal) throws SQLException;

	/**
	 * Sets the designated parameter to the given <code>java.sql.Time</code>
	 * value, using the given <code>Calendar</code> object. The driver uses the
	 * <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
	 * which the driver then sends to the database. With a <code>Calendar</code>
	 * object, the driver can calculate the time taking into account a custom
	 * timezone. If no <code>Calendar</code> object is specified, the driver
	 * uses the default timezone, which is that of the virtual machine running
	 * the application.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @param cal
	 *            the <code>Calendar</code> object the driver will use to
	 *            construct the time
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setTime(String parameterName, java.sql.Time x, Calendar cal) throws SQLException;

	/**
	 * Sets the designated parameter to the given
	 * <code>java.sql.Timestamp</code> value, using the given
	 * <code>Calendar</code> object. The driver uses the <code>Calendar</code>
	 * object to construct an SQL <code>TIMESTAMP</code> value, which the driver
	 * then sends to the database. With a <code>Calendar</code> object, the
	 * driver can calculate the timestamp taking into account a custom timezone.
	 * If no <code>Calendar</code> object is specified, the driver uses the
	 * default timezone, which is that of the virtual machine running the
	 * application.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the parameter value
	 * @param cal
	 *            the <code>Calendar</code> object the driver will use to
	 *            construct the timestamp
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) throws SQLException;

	/**
	 * Sets the designated parameter to SQL <code>NULL</code>. This version of
	 * the method <code>setNull</code> should be used for user-defined types and
	 * REF type parameters. Examples of user-defined types include: STRUCT,
	 * DISTINCT, JAVA_OBJECT, and named array types.
	 * 
	 * <P>
	 * <B>Note:</B> To be portable, applications must give the SQL type code and
	 * the fully-qualified SQL type name when specifying a NULL user-defined or
	 * REF parameter. In the case of a user-defined type the name is the type
	 * name of the parameter itself. For a REF parameter, the name is the type
	 * name of the referenced type. If a JDBC driver does not need the type code
	 * or type name information, it may ignore it.
	 * 
	 * Although it is intended for user-defined and Ref parameters, this method
	 * may be used to set a null parameter of any JDBC type. If the parameter
	 * does not have a user-defined or REF type, the given typeName is ignored.
	 * 
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param sqlType
	 *            a value from <code>java.sql.Types</code>
	 * @param typeName
	 *            the fully-qualified name of an SQL user-defined type; ignored
	 *            if the parameter is not a user-defined type or REF
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.2
	 */
	void setNull(String parameterName, int sqlType, String typeName) throws SQLException;

	// ------------------------- JDBC 3.0 -----------------------------------

	/**
	 * Sets the designated parameter to the given <code>java.net.URL</code>
	 * value. The driver converts this to an SQL <code>DATALINK</code> value
	 * when it sends it to the database.
	 * 
	 * @param parameterName
	 *            the parameterName in sql like :paramName
	 * @param x
	 *            the <code>java.net.URL</code> object to be set
	 * @exception SQLException
	 *                if a database access error occurs
	 * @since 1.4
	 */
	void setURL(String parameterName, java.net.URL x) throws SQLException;
}
